Longest increasing path in a matrix

Time: O(MxN); Space: O(MxN); hard

Given an integer matrix, find the length of the longest increasing path.

From each cell, you can either move to four directions: left, right, up or down.

You may NOT move diagonally or move outside of the boundary (i.e. wrap-around is not allowed).

Example 1:

Input: matrix =

[
  [9,9,4],
  [6,6,8],
  [2,1,1]
]

Output: 4

Explanation:

  • The longest increasing path is [1, 2, 6, 9].

Example 2:

Input: matrix =

[
  [3,4,5],
  [3,2,6],
  [2,2,1]
]

Output: 4

Explanation:

  • The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.

[3]:

class Solution1(object):
    """
    Time: O(M*N)
    Space: O(M*N)
    """
    def longestIncreasingPath(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: int
        """
        if not matrix:
            return 0

        def longestpath(matrix, i, j, max_lengths):
            if max_lengths[i][j]:
                return max_lengths[i][j]

            max_depth = 0
            directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]
            for d in directions:
                x, y = i + d[0], j + d[1]

                if 0 <= x < len(matrix) and \
                   0 <= y < len(matrix[0]) and \
                   matrix[x][y] < matrix[i][j]:
                    max_depth = max(max_depth, longestpath(matrix, x, y, max_lengths))

            max_lengths[i][j] = max_depth + 1

            return max_lengths[i][j]

        res = 0
        max_lengths = [[0 for _ in range(len(matrix[0]))] for _ in range(len(matrix))]

        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                res = max(res, longestpath(matrix, i, j, max_lengths))

        return res

[4]:

s = Solution1()

matrix = [
  [9,9,4],
  [6,6,8],
  [2,1,1]
]
assert s.longestIncreasingPath(matrix) == 4

matrix = [
  [3,4,5],
  [3,2,6],
  [2,2,1]
]
assert s.longestIncreasingPath(matrix) == 4